Browse: 🏠 · Solutions · Connectors · Methods · Tables · Content · Parsers · ASIM Parsers · ASIM Products · Logic Apps · 📊
| Attribute | Value |
|---|---|
| Connector ID | GitHubWebhookV2 |
| Publisher | Microsoft |
| Used in Solutions | GitHub |
| Collection Method | Azure Function |
| Connector Definition Files | GithubWebhookV2_API_FunctionApp.json |
| Ingestion API | Log Ingestion API | Undetermined — Sibling ARM template declares DCR / Log Ingestion API resources; Azure Function code contains both Log Ingestion API and HTTP Data Collector API patterns |
| Custom Log V1 Tables | Yes 🔶 — ingests into tables with type-suffixed columns |
| Microsoft Learn | View on Learn |
The GitHub webhook data connector (V2) provides the capability to ingest GitHub subscribed events into Microsoft Sentinel using GitHub webhook events. This connector uses the Azure Monitor Logs Ingestion API (CLv2) with Managed Identity authentication and is the designated successor to the original GitHub (using Webhooks) connector, which uses the CLv1 HTTP Data Collector API (ODS endpoint) that Microsoft is replacing with CLv2.
Events are written to the GitHubAdvancedSecurityAlerts_CL table. The githubscanaudit parser function provides a unified view across both the legacy githubscanaudit_CL table and the new GitHubAdvancedSecurityAlerts_CL table, so all existing workbooks, analytic rules, and hunting queries continue to work without modification.
Note: If you are currently using the original GitHub (using Webhooks) connector, both connectors can run side-by-side. To avoid duplicate data ingestion, stop the original V1 Function App once you have confirmed V2 is working correctly. See the migration instructions at the bottom of this connector page.
Note: If you intend to ingest GitHub Audit logs, refer to the GitHub Enterprise Audit Log Connector from the "Data Connectors" gallery.
This connector ingests data into the following tables:
| Table | Transformations | Ingestion API | Lake-Only |
|---|---|---|---|
GitHubAdvancedSecurityAlerts_CL 🔶 |
✓ | ✓ | ✓ |
githubscanaudit_CL |
✓ | ✓ | ✓ |
💡 Tip: Tables with Ingestion API support allow data ingestion via the Azure Monitor Data Collector API, which also enables custom transformations during ingestion.
Resource Provider Permissions:
Custom Permissions:
⚠️ Note: These instructions were automatically generated from the connector's user interface definition file using AI and may not be fully accurate. Please verify all configuration steps in the Microsoft Sentinel portal.
NOTE: This connector is built on an HTTP trigger based Azure Function using the Logs Ingestion API (CLv2) with Managed Identity authentication. There is no need to configure a Workspace Key — authentication is handled automatically by the Function App's system-assigned managed identity. This might result in additional data ingestion costs. Check the Azure Functions pricing page for details.
1. Azure public cloud and Azure Government
This webhook connector can ingest events into Azure public cloud or Azure Government. Choose the matching deployment link below. The ARM template configures the DCE endpoint automatically, and the Function App selects the matching Azure Monitor token scope and Microsoft Entra authority from that endpoint. No additional cloud, scope, or authority parameters are required.
For manual deployment, copy the Logs ingestion endpoint from a DCE in the same cloud as your Function App, DCR, and workspace into DCE_ENDPOINT: https://<dce-host>.ingest.monitor.azure.com for Azure public cloud or https://<dce-host>.ingest.monitor.azure.us for Azure Government. Use the actual resource endpoint; do not change an existing endpoint's suffix. The cloud-specific scopes and authorities are described in the Azure Monitor SDK documentation.
GitHub must be able to reach the Function App's HTTPS webhook URL. This connector uses webhooks, not GitHub audit-log streaming to Blob Storage; the Azure Government restriction on the Azure Storage audit-log connector does not apply to this ingestion path.
(Optional Step) Securely store the GitHub Webhook Secret in Azure Key Vault. Follow these instructions to use Azure Key Vault with an Azure Function App.
Choose ONE from the following two deployment options to deploy the connector and the associated Azure Function
IMPORTANT: Before deploying the Github Webhook V2 connector, have the Log Analytics Workspace Name ready. The connector resources (Function App, DCE, DCR, table) must be deployed to the same resource group as the Log Analytics workspace.
WorkspaceNameNote: The value above is dynamically provided when these instructions are presented within Microsoft Sentinel.
Option 1 - Azure Resource Manager (ARM) Template
Use this method for automated deployment of the GitHub V2 data connector using an ARM Template.
Choose the deployment button for your workspace's cloud. No extra Government-specific parameters are required.
Select the Subscription and Resource Group — deploy to the same resource group as your Log Analytics workspace.
NOTE: You can't mix Windows and Linux apps in the same region and resource group.
Option 2 - Manual Deployment of Azure Functions
Use the following step-by-step instructions to deploy the GitHub V2 webhook data connector manually with Azure Functions. Step 1 - Deploy a Function App
1. Download the [Azure Function App](https://aka.ms/sentinel-GitHubWebhookAPIV2-functionapp) file. Extract archive to your local development computer.
Follow the function app manual deployment instructions to deploy the Azure Functions app using VSCode.
After successful deployment of the function app, follow next steps for configuring it.
Step 2 - Configure the Function App
In the Function App, select the Function App Name and select Configuration.
In the Application settings tab, select New application setting.
Add each of the following application settings individually, with their respective string values (case-sensitive):
DCE_ENDPOINT - Copy your DCE's Logs ingestion endpoint: https://<dce-host>.ingest.monitor.azure.com for Azure public cloud or https://<dce-host>.ingest.monitor.azure.us for Azure Government. The Function App automatically selects the matching authentication scope and authority.
DCR_RULE_ID - The immutableId of your Data Collection Rule in the same cloud
DCR_STREAM_NAME - Custom-GitHubAdvancedSecurityAlerts_CL
GithubWebhookSecret (optional) - Your GitHub webhook secret for payload validation
Once all application settings have been entered, click Save.
Ensure the Function App has a System Assigned Managed Identity enabled.
Grant the Managed Identity the Monitoring Metrics Publisher role on your Data Collection Rule.
Post Deployment steps
STEP 1 - To get the Azure Function url
STEP 2 - Configure Webhook to Github Organization
Now we are done with the GitHub Webhook V2 configuration. Once GitHub events are triggered, after the delay of 5 to 10 mins, you should be able to see all the transactional events from GitHub in the LogAnalytics workspace table called GitHubAdvancedSecurityAlerts_CL. Use the githubscanaudit parser function for a unified view that includes data from both the legacy githubscanaudit_CL and new GitHubAdvancedSecurityAlerts_CL tables.
5. ⚠️ IMPORTANT: Migrating from GitHub Webhook V1 to V2
If you are currently using the original GitHub (using Webhooks) connector (githubscanaudit_CL table), follow these steps to migrate to V2 without disrupting existing data or breaking workbooks and analytic rules.
Before you begin: Both connectors can run side-by-side. V1 data lands in githubscanaudit_CL and V2 data lands in GitHubAdvancedSecurityAlerts_CL. The githubscanaudit() parser function unions both tables so all workbooks, analytic rules, and hunting queries continue to work unchanged during and after migration.
Migration Steps:
Deploy V2 alongside V1. Complete all steps above to deploy the GitHub Webhook V2 Function App. Do not remove V1 yet.
Verify V2 is receiving events. Update the GitHub webhook payload URL in your GitHub Organization settings (Settings → Webhooks) to point to the new V2 Function App URL. Trigger some GitHub events and confirm data appears in GitHubAdvancedSecurityAlerts_CL within 5–10 minutes.
Validate the unified parser. Run githubscanaudit() | sort by TimeGenerated desc | take 50 in Log Analytics to confirm both V1 and V2 data appears under the same schema.
Disable the V1 Function App. Once V2 is confirmed working, stop the original V1 Function App to prevent duplicate event ingestion:
Retain V1 data. The githubscanaudit_CL table data is subject to your Log Analytics workspace retention policy. No action is required — historical V1 data continues to be queryable via githubscanaudit() until it ages out per your retention settings.
⚠️ Warning: Do not delete the V1 Function App resources until you have verified V2 is fully operational and you no longer need to roll back. Running both simultaneously does not cause duplicate ingestion as long as only one webhook URL is active in GitHub at a time.
📄 Source: [GitHub\Data Connectors\GithubWebhookV2\README.md](https://github.com/Azure/Azure-Sentinel/blob/master/Solutions/GitHub\Data Connectors\GithubWebhookV2\README.md)
⚠️ IMPORTANT: Migrate to V2
The original GitHub Webhook connector (
GithubWebhook) uses the Azure Monitor HTTP Data Collector API (CLv1 / ODS endpoint). Microsoft is replacing this API with the Logs Ingestion API (CLv2). V2 of this connector is the strategic replacement and should be used for all new deployments. Existing V1 deployments should be migrated to V2.See the Migrating from V1 section below for step-by-step instructions.
This connector is the designated successor to the original GitHub Webhook connector and ingests GitHub webhook events into Microsoft Sentinel using the Logs Ingestion API (CLv2) with Managed Identity authentication. It replaces the CLv1 HTTP Data Collector API (ODS endpoint) used by the original connector.
As of now the solution supports the following GitHub Advanced Security events:
| V1 (original) | V2 (this connector) | |
|---|---|---|
| API | HTTP Data Collector API (ODS) — being replaced by CLv2 | Logs Ingestion API (CLv2/GIG) |
| Auth | SharedKey (WorkspaceID + WorkspaceKey) |
Managed Identity (DefaultAzureCredential) |
| Table | githubscanaudit_CL |
GitHubAdvancedSecurityAlerts_CL |
| Column names | Auto-generated _s / _d / _b suffixes |
Explicit schema, identical _s / _d / _b names |
| Unified view | githubscanaudit_CL only |
githubscanaudit parser (unions both tables) |
| Recommendation | Migrate to V2 | ✅ Recommended for all deployments |
GitHub Org Webhook
│ POST (HMAC-SHA256 signed)
▼
Azure Function App (HTTP trigger)
├── GithubWebhookConnectorV2/__init__.py
│ ├── Verify x-hub-signature-256 (HMAC-SHA256)
│ ├── customizeJson() — flatten nested JSON to _s strings
│ └── LogsIngestionClient.upload() → DCE → DCR
│
├── System-assigned Managed Identity
│ └── Monitoring Metrics Publisher role on DCR
│
└── App Settings
├── DCE_ENDPOINT
├── DCR_RULE_ID
├── DCR_STREAM_NAME (Custom-GitHubAdvancedSecurityAlerts_CL)
└── GithubWebhookSecret (optional, for HMAC validation)
DCR → Log Analytics Workspace → GitHubAdvancedSecurityAlerts_CL table
Best practice: Create a new Resource Group for this connector — all provisioned resources (Function App, Storage Account, DCE, DCR, App Insights) will reside there.
Choose the deployment link for your workspace's cloud. No additional cloud, token-scope, or authority parameters are required: ARM supplies the deployed DCE's ingestion endpoint, and the Function App selects the matching authentication settings automatically.
| Cloud | DCE endpoint suffix | Microsoft Entra authority | Azure Monitor token scope |
|---|---|---|---|
| Azure public cloud | .ingest.monitor.azure.com |
login.microsoftonline.com |
https://monitor.azure.com//.default |
| Azure Government | .ingest.monitor.azure.us |
login.microsoftonline.us |
https://monitor.azure.us/.default |
For manual deployments, copy the actual Logs ingestion endpoint from your
DCE into DCE_ENDPOINT. Do not change an endpoint's suffix to move it between
clouds. Keep the Function App, DCE, DCR, and workspace in the same cloud. Invalid
or unsupported endpoint hosts fail at startup instead of falling back to the
public-cloud authentication scope. See the
Azure Monitor SDK's non-public cloud configuration.
GitHub must be able to reach the Function App's HTTPS webhook URL. This connector uses webhooks, not GitHub audit-log streaming to Blob Storage; the Azure Government restriction on the Azure Storage audit-log connector does not apply to this path.
Required parameters:
| Parameter | Description |
|---|---|
FunctionName |
Name for the new Function App (default: fngithubwebhookv2) |
WorkspaceName |
The name of your Log Analytics workspace (e.g. my-sentinel-workspace). Deploy to the same resource group as the workspace. |
GithubWebhookSecret |
(Optional) Secret string used to validate the x-hub-signature-256 header sent by GitHub |
The template automatically provisions:
GitHubAdvancedSecurityAlerts_CLtransformKql: "source" passthroughGitHubAdvancedSecurityAlerts_CL table with the schema defined in the ARM template.GitHubAdvancedSecurityAlerts_CL.| Setting | Value |
|---|---|
DCE_ENDPOINT |
Actual Logs ingestion endpoint from a DCE in your cloud: https://<dce-host>.ingest.monitor.azure.com for Azure public cloud or https://<dce-host>.ingest.monitor.azure.us for Azure Government. Authentication settings are selected automatically. |
DCR_RULE_ID |
immutableId of your DCR |
DCR_STREAM_NAME |
Custom-GitHubAdvancedSecurityAlerts_CL |
GithubWebhookSecret |
(Optional) Your GitHub webhook secret |
In the Azure Portal, go to your Function App → Overview → Functions → click GithubWebhookConnectorV2.

Click Get Function URL (highlighted below) and copy the URL.

(Optional) Generate a new function key and substitute it into the URL as the code query parameter.
Public-cloud example: https://<function-app>.azurewebsites.net/github/GithubWebhookConnectorV2?code={apikey}.
Azure Government example: https://<function-app>.azurewebsites.us/github/GithubWebhookConnectorV2?code={apikey}.
Always copy the actual Get Function URL value rather than constructing it.

Go to GitHub → click your avatar → Your Organizations.
Open the Organization → click Settings.

Click Webhooks → Add webhook and fill in the form:
application/jsonGithubWebhookSecret value (if set)
Click Add webhook. GitHub will send a ping event — the Function App should return HTTP 200.
After 5–10 minutes (Log Analytics needs time to spin up resources on first ingest), events will appear in the GitHubAdvancedSecurityAlerts_CL table:

Tip for testing secret scanning: GitHub's built-in secret patterns require real credential formats. To reliably trigger a
secret_scanning_alertwebhook during testing, create a custom secret scanning pattern in your Organization settings using the patternTEST_SECRET_[A-Z0-9]{32}and commit a matching string such asTEST_SECRET_ABCD1234EFGH5678IJKL9012MNOP3456to a repository.
| Query | Description |
|---|---|
GitHubAdvancedSecurityAlerts_CL \| sort by TimeGenerated desc |
All V2 events |
githubscanaudit \| sort by TimeGenerated desc |
Unified view (V1 + V2, all historical data) |
GitHubCodeScanningData |
Code scanning alerts (uses githubscanaudit — works with both tables) |
GitHubDependabotData |
Dependabot vulnerability alerts |
GitHubSecretScanningData() |
Secret scanning alerts |
⚠️ Microsoft is replacing the CLv1 HTTP Data Collector API (used by the original GitHub Webhook connector) with the Logs Ingestion API (CLv2). V2 is the recommended replacement. Migrate existing V1 deployments to V2 to remain on a supported ingestion path.
Because both tables share identical column names (_s / _d / _b suffixes), all existing workbooks, analytic rules, hunting queries, and parsers (GitHubCodeScanningData, GitHubDependabotData, GitHubSecretScanningData) continue to work without modification via the githubscanaudit union parser.
Migration Steps:
Deploy V2. Complete all deployment steps above.
Update the GitHub webhook URL. In your GitHub Organization (Settings → Webhooks), update the payload URL to point to the new V2 Function App URL. This immediately redirects new events to V2.
Verify V2 is receiving events. Trigger some GitHub events and confirm data appears in GitHubAdvancedSecurityAlerts_CL within 5–10 minutes.
Validate the unified parser. Run the following in Log Analytics to confirm events appear:
githubscanaudit
| sort by TimeGenerated desc
| take 50
Stop the V1 Function App. Once V2 is confirmed working:
Retain V1 historical data. The githubscanaudit_CL table data is subject to your workspace retention policy. No action is required — historical V1 data remains queryable via githubscanaudit until it ages out.
Note: Do not delete V1 Function App resources until you are satisfied V2 is fully operational and you do not need to roll back.
GithubWebhookV2/
├── GithubWebhookConnectorV2/
│ ├── __init__.py # Azure Function — CLv2 ingestion logic
│ └── function.json # HTTP trigger binding
├── azuredeploy_GithubWebhookV2_API_FunctionApp.json # ARM template
├── GithubWebhookV2_API_FunctionApp.json # Connector definition
├── GithubWebhookV2.zip # Pre-built Linux deployment package
├── host.json # Function host settings (retry, timeout)
├── requirements.txt # Python dependencies
└── README.md # This file
Install requirements.txt in a Python 3.11 virtual environment, then run:
python -m unittest discover -s "Solutions\GitHub\Data Connectors\GithubWebhookV2\tests" -v
The tests exercise both clouds using the real ingestion SDK with a local, no-network transport, including token scopes, webhook signatures, error handling, and the deployment ZIP's source contents. They do not replace an end-to-end deployment in Azure Government.
After changing the Function App code, rebuild GithubWebhookV2.zip with
Linux-compatible Python 3.11 dependencies from requirements.txt. The archive root
must contain host.json, requirements.txt, GithubWebhookConnectorV2/, and
.python_packages/lib/site-packages/. Do not include tests or a parent directory.
The ARM template's WEBSITE_RUN_FROM_PACKAGE and the manual-download link must
resolve to this updated package when the change is published.
githubscanaudit union parserBrowse: 🏠 · Solutions · Connectors · Methods · Tables · Content · Parsers · ASIM Parsers · ASIM Products · Logic Apps · 📊